Basic Plot - Drawto in Assembler

Lies mal den Artikel "Schnelle Vektoren in Action!" aus ATARIMAGAZIN von P.Finzel. Dort beschreibt er einen Algorithmus, der schneller ist als die OS Routine.

https://atariwiki.org/wiki/Wiki.jsp?page=Action#section-Action-ATARImagazin

Schau mal in den MADS examples Ordner. Dort findest Du fast draw.

Dr. Irata schrieb: ... vielen Dank. Sehr interessanter Artikel (wie immer bei Peter Finzel). Leider in Action! geschrieben.

http://www.atarimania.com/mags/pdf/Atari-Magazin-89-11-12.pdf

Seite 39 dürftest Du in Assembler fündig werden...

Das ist etwas versteckt. Habe mal kurz im github geschaut. Ich weiß, dass auch noch mehr Beispiele drin waren. Hier aber eines:

line.asm im examples Ordner

Das ist nicht eigenständig, sondern gehört zur graphics library.

Dr. Irata schrieb: Ich muss ja zum zeichnen der Gerade nur einmal teilen - am Anfang - und danach setze ich nur noch die Pixel in Abhängigkeit der Steigung m. Wenn die Steigung m beispielsweise 3 beträgt, dann muss ich nach jeden Schritt nach vorne 3 Schritte hoch gehen usw.

Wenn die Steigung z.B. 2.5 ist, bekommst Du für die "Unterschlagung" der Nachkommastellen mit Deiner Assemblerroutine "lustige" Ergebnisse...

Ich bin gespannt...

Dr. Irata schrieb: Den Fehler muss man evt. ausbügeln. Das Verfahren ist ja auch nur eine Art Näherung.

Der Fehler muss in den Algorithmus einfließen. Mit einem Algorithmus à la "nach zwei Pixel hoch, einen nach rechts" bekommst Du nicht immer eine Verbindung zwischen zwei Punkten:

Du kannst Dir eine Menge Zeit und Aufwand sparen (und hast dabei noch den schnellsten Algorithmus), wenn Du Bresenham anwendest...

Dr. Irata schrieb: wäre das ein Extrabeitrag fürs Magazin?? :D

Ja !!

Ich habe in meinem PDF Archiv noch Artikel zu diesem Thema gefunden (siehe Anhänge).

Dr. Irata schrieb: Nun kann ich die anderen Fälle programmieren, damit kann man die Gerade in alle Richtungen zeichnen. Im Anschluss mache ich eine kleine animierte Demo...

Es werden weniger Fälle, wenn Start- und Endpunkt vorher getauscht werden, falls sie "ungünstig" liegen....

Noch ein Tipp: Beim 6502 ist es schneller man adressiert 16bit über 2 Tabellen (Hi- und Low-Byte getrennt).

Mal ein Auszug aus meiner Grafik-Lib:

; Calculates and returns actual adress of line respective to screen base address,
; row offset value and given y/line number
; BYTE* __fastcall__
; Screen_GetRowAddress(BYTE nRow_);

.export _Screen_GetRowAddress
.proc   _Screen_GetRowAddress
        tay                         ; line to table index
        lda _ScreenRowAdrTableL, Y  ; access table (low)
        ldx _ScreenRowAdrTableH, Y  ; access table (high)
        rts
.endproc

Und noch zwei Artikel gefunden:

Dr. Irata schrieb: bedeutet das, wenn ich zum Beispiel statt mwa convx,x jump zunächst mva conv1 jump1 für low Byte und dann mva conv2 jump2 für high Byte selbstmodifiziedend aus 2 Tabellen hole und hinter jsr 0 platziere - ist das schneller???

Halleluja, so wie Du das gemacht hast, wäre mir gar nicht eingefallen. Mit haben schon die z.B. 192*2 Bytes (Antic F) für die Zeilenadresstabelle weh getan, aber für jede Zeile noch mal 9 Bytes für die Plot-Routine ist schon beachtlich - auch deswegen, weil Du für typische Anwendungsfälle nicht mit EOR auskommst, sondern AND zum Löschen und OR zum "Zeichnen" brauchst (was den Code nochmal aufbläht).

Ich benutze nicht MADS und tue mich mit den "mwa/mva"-Macros immer schwer. Aber optimal scheint mir das Vorgehen nicht zu sein. (Ich verstehe auch nicht ganz Deinen +50, +100, +150 Offset (falls Du nicht eine spezielle Display-List hast, sollten Deine Zeilen 40 Bytes breit sein...?))

Ganz klassisch würde das EOR-Plotten ungefähr so aussehen:

; Routine zum Plotten, X = x-Koordinate; Y = Y-Koordinate, zpPtr = 16-Bit Wort in der Zero-Page
Plot:
        lda _ScreenRowAdrTableL, Y  ; access table (low)
        sta zpPtr
        lda _ScreenRowAdrTableH, Y  ; access table (high)
        sta zpPtr+1
        txa                             ; 
        lsr a                           ; / 2
        lsr a                           ; / 4 ( 4 Pixel / Byte )
        tay                             ; = zeilen offset

        ; hier könnte code stehen der 'phase' (aus Deinem Code) errechnet
        ; aus der X-coordinate 2 bits nimmt für eine Maske aus einer Tabelle
        ; txa
        ; and #3
        ; tax
        ; lda PixelMask, x      ; farbabhängig 
        ; sta phase

        lda (zpPtr), Y
        eor phase
        sta (zpPtr), Y

        rts

PixelMask:
.byte   %00000011
.byte   %00001100
.byte   %00110000
.byte   %11000000

Es gibt noch genug zum Austoben: Der Trick bei einer Linienroutine ist nicht einzelne Pixel zu plotten, sondern das Wissen, dass sie benachbart sind code-technisch elegant auszunutzen... (z.B. selbe Zeile, selbes Byte etc.)

Noch ein Tipp: Statt

            jsr irgendwohin
            rts

kann man auch

            jmp irgendwohin

schreiben und spart Zeit und ein Byte...

Und noch ein Hinweis: Die Literatur, die 'cas' hier verlinkt hat ist sicherlich interessant, aber wenn sie für den C64 ist sehr mit Vorsicht zu genießen. Der C64 hat ein ganz anderen Bildschirmspeicheraufbau, was die Sache noch komplizierter macht...

Weiterhin viel Spaß beim Entdecken!

cas schrieb: Und noch zwei Artikel gefunden:

Eine Info zum C64 und dessen HiRes Grafik.

• Beim AtariXL ist die Grafik wirklich Zeilenweise angeordnet. Also das das nächste Byte (+1) liegt in der selben Zeile nur halt ein paar Pixel weiter rechts.

Ein Index sieht so aus... 0, 1, 2, 3, ... 39, 40,41,42... ...

• Beim C64 ist die Anordnung eher wie beim Zeichensatz. 8 Bytes untereinander, dann kommen die nächsten 8 Bytes untereinander...

Ein Index beim C64 sieht so aus... 0,8,16,24, ... 312, 1,9,17, 2,10,18, 3,11,19, ... 7,15,23,...

320,328,... 321,... ...

Das sollte man berücksichtigen, wenn man sich C64-Linienalgorithmen ansieht und versucht diese zu verstehen.

LG Lars

Ich bin auch kein Fan von MADS und mva/mwa. Das wird sich erst ändern, wenn es den Assembler native auf Linux gibt. BTW: Wine ist nicht Linux.

LarsImNetz schrieb: Ich bin auch kein Fan von MADS und mva/mwa. Das wird sich erst ändern, wenn es den Assembler native auf Linux gibt. BTW: Wine ist nicht Linux.

Hallo Lars,

warum "wenn", den gibt es doch schon lange (eigendlich seit immer) "nativ" unter Linux:

apt install fpc
git clone https://github.com/tebe6502/Mad-Assembler
cd Mad-Assembler
fpc -Mdelphi -vh -O3 mads.pas
sudo cp mads /usr/local/bin

Ich kann Dir gerne auch ein "mads" binary für i686/amd64/arm/aarch64/m68k kompilieren.

passt schon, hab ihn gerade selbst gebaut.

So, hier mal eine etwas schnellere Line-Zeichen-Routine. Es gab mal irgendwo einen Source mit 8 Versionen, das hier ist die letzte davon.

Die Routine schafft locker 300 Linien pro Sekunde. (rand(160), rand(192),rand(160), rand(192)) ist leider etwas ungenau, dafür verdammt flott.

Die Parameterübergabe ist für meinen Compiler, ähnlich wie beim cc65. Per (heap_ptr),y realisiert. Wenn man sich die komplizierte, teure Parameterübergabe spart, ist diese Routine noch schneller. Der Code ist kompatibel zum Atasm Assembler. Der Code zeichnet 4 Pixel gleichzeitig, mehr hab ich bisher auch nicht verstanden.

Wirklich das schnellste, was ich bisher gesehen habe. Ich habe auch den Code von ERU, zum Vergleich, die schafft ca. 216 Linien pro Sekunde, nur um mal ein paar Zahlen zu nennen. Mit einfachem Bresenham komme ich in meinem Compiler nicht über 80 Linien pro Sekunde, was aber am expliziten PLOT(x,y) liegt.

Wer die Routine nutzen möchte, sollte die @MULT40_low und _high Tabelle noch setzen, hab ich hier nicht mit angegeben.

LG Lars

  .LOCAL

; TODO
; Dieser LINE Algorithmus funktioniert nur
; in graphics 7 und 15 (40 Bytes breit)
; bis 160 x 192!!! Weil nur 8 Bit breit
; ist dafuer sehr schnell, leider ungenau => eher unbrauchbar

; BITMSK    = $6E
; SHFAMT    = $6F
;ROWCRS = $54
;COLCRS = $55
;OLDROW = $5A
;OLDCOL = $5B
;ROWAC  = $70
;ROWADC     = $72
;CFLAG  = $74
;RFLAG  = $75
;DELTAROW= $76
;DELTACOL= $77
;ATACHR = $02FB

;opcodes for self-modifying code
?_OC_BIT_0P_ = $24
?_OC_DEC_0P_ = $C6 ;11000110
?_OC_INC_0P_ = $E6 ;11100110 ;XOR 32 ;$20
?_OC_DEX_   = $CA  ;11001010
?_OC_INX_   = $E8  ;11101000 ;XOR 34 ;$22
?_OC_AND_AX_ = $3D
?_OC_EOR_AX_ = $5D
?_OC_ORA_AX_ = $1D

; @REG ist bei mir ab Adresse 220 (Floating-Point-Register) 
?L0  = @REG+0 ; $B0
?L1  = @REG+1 ; $B1

?L2  = @REG+2 ; $B2
?L3  = @REG+3 ; $B3

?L4  = @REG+4 ; $B4
?L5  = @REG+5 ; $B5

?L6  = @REG+6 ; $B6
?L7  = @REG+7 ; $B7

?m0 = @REG+8
?m1 = @REG+9
?m2 = @REG+10

?x0 = @REG+11
?x1 = @REG+12
?x2 = @REG+13


@SETLINECOLOR
@SETLINECOLOR_i
        LDY #1            ; color 0 - 3
        LDA (@HEAP_PTR),Y ; wert holen
        and #3
        TAX

    LDY ?MASTSET,X
    STY ?SET1IMASKT
    STY ?SET1IMASKW
    STY ?SET2IMASKT
    STY ?SET2IMASKW
    STY ?SET3IMASKT
    STY ?SET3IMASKW
    STY ?SET4IMASKT
    STY ?SET4IMASKW
    LDA ADRCOLMHI,X
    STA ?GET1CMASKHT
    STA ?GET1CMASKHW
    STA ?GET2CMASKHT
    STA ?GET2CMASKHW
    STA ?GET3CMASKHT
    STA ?GET3CMASKHW
    STA ?GET4CMASKHT
    STA ?GET4CMASKHW
    RTS


; DRAWLINE ;v6
;   LDA #1
;   STA OLDROW
;   LDA #153
;   STA OLDCOL
;   LDA #072
;   STA ROWCRS
;   LDA #1
;   STA COLCRS
@LINE
@LINE_IIII
@FASTLINE2BIT
@FASTLINE2BIT_IIII
  LDY #1            ; XSTART
  LDA (@HEAP_PTR),Y ; wert holen
  STA OLDCOL ; ?XSTART

  LDY #3            ; YSTART
  LDA (@HEAP_PTR),Y ; wert holen
  STA OLDROW ; ?YSTART

  LDY #5            ; XEND
  LDA (@HEAP_PTR),Y ; wert holen
  STA COLCRS ; ?XEND

  LDY #7            ; YEND
  LDA (@HEAP_PTR),Y ; wert holen
  STA ROWCRS ; ?YEND

  LDA OLDROW
    SEC
    SBC ROWCRS
    BCS ?OLDROWFIRST

    LDX OLDCOL ;3
    LDY COLCRS ;3
    STY OLDCOL ;3
    STX COLCRS ;3
    LDY OLDROW
    SBC #0
    EOR #255
    JMP ?STOREROWDELTA

?OLDROWFIRST
    LDY ROWCRS

?STOREROWDELTA
    STA ?aw_WIDE_DELTA_RI
    STA ?aw_TALL_DELTA_RI
    LSR A
    LSR A
    STA ?X1
    BNE ?NOVS2
    BCC ?NOVS2
    LDA #01
?NOVS2
    STA ?m2
    LDA @MULT40_LOW,Y
    STA ?L0
    LDA @MULT40_HIGH,Y
    STA ?L1

    TYA
    CLC
    ADC ?X1
    TAY
    LDA @MULT40_LOW,Y
    STA ?L2
    LDA @MULT40_HIGH,Y
    STA ?L3

    TYA
    CLC
    ADC ?m2
    TAY
    LDA @MULT40_LOW,Y
    STA ?L4
    LDA @MULT40_HIGH,Y
    STA ?L5

    TYA
    CLC
    ADC ?X1
    TAY
    LDA @MULT40_LOW,Y
    STA ?L6
    LDA @MULT40_HIGH,Y
    STA ?L7

    LDA OLDCOL
    SEC
    SBC COLCRS
    BCS ?aw_HOZ_POS

?aw_HOZ_NEG
    SBC #0
    EOR #255
    TAY
    LSR A
    LSR A
    STA ?m1
    STA ?x0
    STA ?X2
    BNE ?noHS1
    BCC ?noHS1

    LDA #1
?noHS1
    STA ?m2

    LDA COLCRS
    SEC
    SBC ?X2
    STA ?GET1CMASKLW
    STA ?GET1TABLW
    STA ?GET1CMASKLT
    STA ?GET1TABLT

    SBC ?m2
    STA ?GET2CMASKLW
    STA ?GET2TABLW
    STA ?GET2CMASKLT
    STA ?GET2TABLT

    SBC ?X2
    STA ?GET3CMASKLW
    STA ?GET3TABLW
    STA ?GET3CMASKLT
    STA ?GET3TABLT

    SBC ?X2
    STA ?GET4CMASKLW
    STA ?GET4TABLW
    STA ?GET4CMASKLT
    STA ?GET4TABLT
    LDX #?_OC_DEX_
    JMP ?compARE_SLOPE

?aw_HOZ_POS
    TAY
    LSR A
    LSR A
    STA ?X2
    BNE ?noHS2
    BCC ?noHS2

    LDA #01
?noHS2
    STA ?m2
    LDA COLCRS
    STA ?GET1CMASKLW
    STA ?GET1TABLW
    STA ?GET1CMASKLT
    STA ?GET1TABLT

    CLC
    ADC ?X2
    STA ?GET2CMASKLW
    STA ?GET2TABLW
    STA ?GET2CMASKLT
    STA ?GET2TABLT

    ADC ?m2
    STA ?GET3CMASKLW
    STA ?GET3TABLW
    STA ?GET3CMASKLT
    STA ?GET3TABLT

    ADC ?X2
    STA ?GET4CMASKLW
    STA ?GET4TABLW
    STA ?GET4CMASKLT
    STA ?GET4TABLT
    STA ?m0

    LDX #0
    STX ?x0
    LDX #?_OC_INX_
?compARE_SLOPE
    CPY ?aw_WIDE_DELTA_RI
    BCC ?aw_TALLSLOPE
    BEQ ?aw_TALLSLOPE

?aw_WIDESLOPE
    STY ?aw_WIDE_DELTA_CI
    TYA
    SEC
    SBC ?m2
    STA ?m1
  STX ?COLADC1
    LDA ?X2
    BEQ ?aw_WIDESLOPE0

    SEC
    LDX ?x0
?aw_WIDE_LOOP

?COLADC1
    INX         ;2
?GET1TABLW = *+1
    LDY ?TAB4DIV,X      ;6
    LDA (?L0),Y     ;11
?SET1IMASKW = *
?GET1CMASKLW = *+1
?GET1CMASKHW = *+2
    ORA $FF00,X     ;15
    STA (?L0),Y     ;20

?GET2TABLW = *+1
    LDY ?TAB4DIV,X      ;24
    LDA (?L2),Y     ;29
?SET2IMASKW = *
?GET2CMASKLW = *+1
?GET2CMASKHW = *+2
    ORA $FF00,X     ;33
    STA (?L2),Y     ;38

?GET3TABLW = *+1
    LDY ?TAB4DIV,X      ;42
    LDA (?L4),Y     ;47
?SET3IMASKW = *
?GET3CMASKLW = *+1
?GET3CMASKHW = *+2
    ORA $FF00,X     ;51
    STA (?L4),Y     ;56

?GET4TABLW = *+1
    LDY ?TAB4DIV,X      ;60
    LDA (?L6),Y     ;65
?SET4IMASKW = *
?GET4CMASKLW = *+1
?GET4CMASKHW = *+2
    ORA $FF00,X     ;69
    STA (?L6),Y     ;74

    LDA ?m1         ;77 -3
?aw_WIDE_DELTA_RI=*+1
    SBC #$FF        ;79 -5
    STA ?m1         ;82 -8
    BCS ?aw_WIDE_SKIP   ;85
?aw_WIDE_DELTA_CI=*+1
    ADC #$FF
    STA ?m1

    LDA ?L0
    CLC
    ADC #40
    STA ?L0
    BCC ?no_WIDE_H1INC
    INC ?L1

    CLC
?no_WIDE_H1INC
    LDA ?L2
    ADC #40
    STA ?L2
    BCC ?no_WIDE_H2INC
    INC ?L3

    CLC
?no_WIDE_H2INC
    LDA ?L4
    ADC #40
    STA ?L4
    BCC ?no_WIDE_H3INC
    INC ?L5

    CLC
?no_WIDE_H3INC
    LDA ?L6
    ADC #40
    STA ?L6
    BCC ?no_WIDE_H4INC
    INC ?L7
?no_WIDE_H4INC

    SEC
?aw_WIDE_SKIP

?LAST_WIDE_X = *+1
    DEC ?X2         ;88
    BNE ?aw_WIDE_LOOP   ;91

?aw_WIDESLOPE0
    RTS

;
?aw_TALLSLOPE
    STY ?aw_TALL_DELTA_CI
    LDA ?aw_TALL_DELTA_RI
    SEC
    SBC ?m2
    STA ?m1
    DEC ?X1
    BEQ ?aw_WIDESLOPE0
    BMI ?aw_WIDESLOPE0
  STX ?COLADC2
    LDX ?x0
?aw_TALL_LOOP

?GET1TABLT = *+1
    LDY ?TAB4DIV,X   ;4
    LDA (?L0),Y      ;9
?SET1IMASKT = *
?GET1CMASKLT = *+1
?GET1CMASKHT = *+2
    ORA $FF00,X        ;14
    STA (?L0),Y      ;19

?GET2TABLT = *+1
    LDY ?TAB4DIV,X   ;23
    LDA (?L2),Y      ;28
?SET2IMASKT = *
?GET2CMASKLT = *+1
?GET2CMASKHT = *+2
    ORA $FF00,X        ;32
    STA (?L2),Y      ;37

?GET3TABLT = *+1
    LDY ?TAB4DIV,X   ;4
    LDA (?L4),Y      ;9
?SET3IMASKT = *
?GET3CMASKLT = *+1
?GET3CMASKHT = *+2
    ORA $FF00,X        ;14
    STA (?L4),Y      ;19

?GET4TABLT = *+1
    LDY ?TAB4DIV,X   ;23
    LDA (?L6),Y      ;28
?SET4IMASKT = *
?GET4CMASKLT = *+1
?GET4CMASKHT = *+2
    ORA $FF00,X        ;32
    STA (?L6),Y      ;37

    LDA ?m1            ;40
    SEC                ;42
?aw_TALL_DELTA_CI=*+1
    SBC #$FF    ;44
    BCS ?aw_TALL_SKIP ;47
?aw_TALL_DELTA_RI=*+1
    ADC #$FF    ;

?COLADC2
    INX
?aw_TALL_SKIP
    STA ?m1     ;50

    LDA ?L0     ;53
    CLC     ;55
    ADC #40     ;57
    STA ?L0     ;60
    BCC ?no_TALL_H1INC ;63
    INC ?L1

    CLC
?NO_TALL_H1INC
    LDA ?L2     ;66
    ADC #40     ;68
    STA ?L2     ;71
    BCC ?no_TALLH2DEC ;74
    INC ?L3

?NO_TALLH2DEC
    LDA ?L4     ;53
    CLC     ;55
    ADC #40     ;57
    STA ?L4     ;60
    BCC ?no_TALL_H3INC ;63
    INC ?L5

    CLC
?NO_TALL_H3INC
    LDA ?L6     ;66
    ADC #40     ;68
    STA ?L6     ;71
    BCC ?NO_TALLH4DEC ;74
    INC ?L7

?NO_TALLH4DEC

    DEC ?X1     ;77
    BPL ?AW_TALL_LOOP ;80
?DREND
    RTS

  * = (* +$FF) & $FF00

ANDMASK
    .byte 63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252
    .byte 63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252
    .byte 63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252
    .byte 63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252
    .byte 63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252,63,207,243,252

ADRCOLMLO
    .byte <ANDMASK, <COLORMASK1, <COLORMASK2, <COLORMASK3
ADRCOLMHI
    .byte >ANDMASK, >COLORMASK1, >COLORMASK2, >COLORMASK3

?MASTSET
        .byte ?_OC_AND_AX_, ?_OC_ORA_AX_, ?_OC_ORA_AX_, ?_OC_ORA_AX_
        .byte ?_OC_AND_AX_, ?_OC_EOR_AX_, ?_OC_EOR_AX_, ?_OC_EOR_AX_

;M1DIMG
;   .byte 3,12,48,192
;M2DIMG
;   .byte 1,4,16,64

;EMPTYDATA
;   .byte 0,0,0,0

;   ORG LINEDATAPAGE + 256
  * = (* +$FF) & $FF00
COLORMASK1
    .byte 64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1
    .byte 64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1
    .byte 64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1
    .byte 64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1
    .byte 64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1,64,16,4,1

;   ORG LINEDATAPAGE + 512
  * = (* +$FF) & $FF00
COLORMASK2
    .byte 128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2
    .byte 128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2
    .byte 128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2
    .byte 128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2
    .byte 128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2,128,32,8,2

;   ORG LINEDATAPAGE + 768
  * = (* +$FF) & $FF00
COLORMASK3
    .byte 192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3
    .byte 192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3
    .byte 192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3
    .byte 192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3
    .byte 192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3,192,48,12,3

;   ORG LINEDATAPAGE + 1024
  * = (* +$FF) & $FF00

?TAB4DIV
    .byte 0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9
    .byte 10,10,10,10,11,11,11,11,12,12,12,12,13,13,13,13,14,14,14,14,15,15,15,15,16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19
    .byte 20,20,20,20,21,21,21,21,22,22,22,22,23,23,23,23,24,24,24,24,25,25,25,25,26,26,26,26,27,27,27,27,28,28,28,28,29,29,29,29
    .byte 30,30,30,30,31,31,31,31,32,32,32,32,33,33,33,33,34,34,34,34,35,35,35,35,36,36,36,36,37,37,37,37,38,38,38,38,39,39,39,39


    .align 256

; muessen initialisiert werden! Die zeigen auf den Graphics-Speicher, jeder Wert ist um 40 Bytes groesser

@MULT40_low
 .dc 256 0

@MULT40_high
 .dc 256 0

Dr. Irata schrieb: ... mit welcher Umgebung programmierst du denn??

cc65/ca65

eigentlich versuche ich inzwischen soviel wie geht in cc65 zu schreiben und erst wenn es zeitkritisch wird, entweder cc65 zu verbessern 😀 oder auf Assembler zu wechseln. Klappt bisher ganz gut.

Größte Hürde bei cc65 ist, wenn man es denn irgendwann kann, gleichzeitig die größte Hilfe: Die Linker-Configuration. Gerade beim Atari mit seinen vielen Speicherausrichtungsanforderungen (Zeichensätze, PMG, DL, Bildschirmspeicher) ist das am Anfang kompliziert - inzwischen aber für die Atari-Compound-Dateien besser unterstützt und etwas einfacher.

(Die PixelMask-Tabelle oben ist glaube ich falsch herum, um 1:40 kann das schon einmal passieren... 😉 )

Grüße!

[quote="Dr. Irata" post_id=15255 time=1685089261 user_id=250] Kann man das in Eclipse einbinden??? [/quote]

ACTION! läuft auf dem Atari als Cart, da müsste man den Emulator per Script "fernsteuern". Das habe ich noch nicht getestet, ob es einen Emulator gibt, der das kann. Wäre Interessant das mal herauszufinden.

Unter

New Frontiers in High-Level 6502 Programming https://8bitworkshop.com/docs/posts/2018/higher-level-6502-programming.html#higher-level-6502-programming

gibt es eine lange Liste von sehr interessanten (zum Teil neuen) Programmiersprachen für den A8. Ich suche noch Mitstreiter, welche an einer Artikel-Serie für das ABBUC Magazin mitmachen um diese Sprachen zu testen und auch von der Code-Qualität zu vergleichen.

Bei Interesse bitte melden.

vielleicht noch per Pageflipping arbeiten und dann Quasi die neue Zeile erst anzeigen wenn sie fertig gezeichnet ist...

Wozu willst du die Linie eigentlich verwenden?

Noch gefunden (und gerade geschaut):

Let's Code MS DOS 0x20: Bresenham Line Drawing https://www.youtube.com/watch?v=pMZ-nWpHJdo

Dr. Irata schrieb: sehr cool... allerdings brauche ich jetzt noch einen Füllalgorithmus 😉

Na ja, wenn Du ein ausgefülltes "Labyrinth" haben möchtest, brauchst Du keine Linienzeichenroutine. Der einzig gangbare Weg, so etwas einigermaßen zügig auf dem Atari hinzubekommen ist ein sogenannter "Raycaster". Zu diesem Thema gibt es sehr viel Literatur, Youtube-Tutorials, Beispielcode.

Deine Linienroutine ergibt allerdings Sinn, falls Du eine Drahtgitter 3d-Umgebung erstellen möchtest. Dann brauchst Du aber keinen 'Füllalgorithmus'...

Das Thema lässt mich nicht los ... heute gab es auf HackerNews (https://news.ycombinator.com) einen Link zu diesem Blog-Post

BRR Lines A new line drawing method for the cycle savvy http://www.quiss.org/boo/

Dort hat jemand aus dem C64-Land einen Linien-Algorithmus, welcher oft schneller als Bresenham ist. Ist C64, also anderer Speicher-Layout, aber vielleicht für den A8 adaptierbar.

Hi, hier mal eine simple Line-Demo.

Die zeichnet 17 Pixel auf den Screen. Die Pixel bewegen sich alle gleich schnell in unterschiedliche Richtungen. Erreicht ein Pixel den Rand, fängt er wo anders wieder an.

Wenn der Abstand zwischen 2 Pixeln eine gewisse Schwelle erreicht hat, wird zwischen ihnen eine Linie gezeichnet. Je nach Abstand unterschiedlich hell. Der Algorithmus für die Abstände ist teuer (~O(n^2/2))

Als Line-Routine hab ich die von ERU verwendet (mal in AtariAge gefunden), da dieser saubere Linien zeichnet. Die Rattenschnelle Line-Version hab ich auch mal probiert, aber die Animation ist nicht merklich flotter, dafür fällt extrem stark auf, wie schlecht der Line-Algorithmus wirklich ist.

Als DoubleBuffer habe ich mir etwas zusammengezimmert, es ist nicht perfekt, aber besser als Flackern oder immer den ganzen Screen kopieren.

Nett anzusehen, aber als Speed-Test nicht zu gebrauchen.

LG Lars

Wie genau, hab ich nicht analysiert, aber hier hab ich den her: https://forums.atariage.com/topic/231690-known-fast-line-algorithms/

Der superschnelle ist hier: https://forums.atariage.com/topic/211628-fast-line-drawing/

Und Lines in Chars gibt es dann hier: http://codebase64.org/doku.php?id=base:lines

LG Lars

Neues Video über schnelle Computergrafik von PCRetroTech:

Animating Ellipses on a Vintage 386 Computer https://www.youtube.com/watch?v=d8ulXJZD0P8

erklärt die Algorithmen hinter Linien, Kreise und Ellipsen